
import type {
  IOrganizationTree,
  IOrganization,
  IOrganizationState
} from '../types/10-organization'

/**
 * 后端的结构转换为树状结构
 * @param state 状态，orgTree：树状的部门信息；orgList：后端列表；orgObject：key-value的
 */
export function listToTree(state: IOrganizationState) {
  //从状态中获取部门信息
  const { orgTree, orgList, orgObject } = state

  const tmp = {} // 中转容器
  // 第一次遍历，转换为 key 的形式
  orgList.forEach((org: IOrganization) => {
    orgObject[org.id] = org // 存入 key-value，非必要
    tmp[org.id] = {
      id: org.id,
      label: org.deptName,
      children: []
    }
  })

  // 第二次遍历，寻找父节点
  orgList.forEach((org: IOrganization) => {
    // 判断父级
    if (tmp[org.parentId]) {
      // 有父级，加入 children
      tmp[org.parentId].children.push(tmp[org.id])
    } else {
      // 顶级，加入 orgTree
      orgTree.push(tmp[org.id])
    }
  })
}


/**
 * tree 转换为转换为后端的形式
 * @param state 状态，orgList：后端列表，目标。orgObject：key-value;currentOrg.sortAll 全排列
 * @param parentId 父级ID，第一次传 0
 * @param level 层数，第一次传 0
 * @param path 路径，第一次传 ''
 * @param treeNode 节点
 * @param parentSort 同级里的序号，第一次传 1
 */
export function treeToList(
  state: IOrganizationState, // 
  parentId: number | string,
  level: number,
  path: string,
  treeNode: IOrganizationTree,
  parentSort: number
) {

  // 把 node 存入 list
  // 判断有无children 
  // 没有，结束递归
  // 有，递归

  // 设置 orgObject
  const org = state.orgObject[treeNode.id]
  org.level = level
  org.parentId = parentId
  org.path = path + parentId + ','
  org.sort = parentSort * 10
  org.sortAll = (state.currentOrg.sortAll++ ) * 10

  // 把 部门信息 存入 list
  state.orgList.push({
    id: treeNode.id,
    deptName: treeNode.label, // 部门名称
    level: level, // 层级
    parentId: parentId, // 上级部门ID
    path: org.path, // 父ID集合，“,”号分割
    sort: org.sort, // 同一个父级里的先后顺序
    sortAll: org.sortAll // 部门全排列
  })

  // 判断有无children 
  if (treeNode.children && treeNode.children.length > 0) {
    // 有，递归
    treeNode.children.forEach((node: IOrganizationTree, index: number) => {
      treeToList(state, treeNode.id, level + 1, org.path, node, index + 1)
    })
  } else {
    // 没有，退出递归
  }
}